import api from './index'


// 角色相关API
export const roleAPI = {
    // 分页查询角色
    getRoles(params) {
        return api.get('/api/role/page', { params })
    },

    // 根据ID查询角色
    getRoleById(id) {
        return api.get(`/api/role/${id}`)
    },

    // 新增角色
    createRole(data) {
        return api.post('/api/role', data)
    },

    // 修改角色
    updateRole(data) {
        return api.put('/api/role', data)
    },

    // 删除角色
    deleteRole(id) {
        return api.delete(`/api/role/${id}`)
    }
}

// 角色权限关联API
export const rolePermissionAPI = {
    // 分页查询角色权限关联
    getRolePermissions(params) {
        return api.get('/api/role-permission/page', { params })
    },

    // 根据ID查询角色权限关联
    getRolePermissionById(id) {
        return api.get(`/api/role-permission/${id}`)
    },

    // 新增角色权限关联
    createRolePermission(data) {
        return api.post('/api/role-permission', data)
    },

    // 修改角色权限关联
    updateRolePermission(data) {
        return api.put('/api/role-permission', data)
    },

    // 删除角色权限关联
    deleteRolePermission(id) {
        return api.delete(`/api/role-permission/${id}`)
    },

    // 批量分配权限给角色（使用后端批量接口）
    async assignPermissionsToRole(roleId, permissionIds) {
        if (!permissionIds || permissionIds.length === 0) {
            return { success: true, message: '没有权限需要分配' }
        }

        try {
            // 构建批量请求数据
            const batchData = permissionIds.map(permissionId => ({
                roleId: roleId,
                permissionId: permissionId
            }))

            // 使用后端批量接口
            const response = await api.post('/api/role-permission/batch', batchData)
            
            if (response.success) {
                return { success: true, message: `成功分配 ${permissionIds.length} 个权限` }
            } else {
                throw new Error(response.message || '批量分配权限失败')
            }
        } catch (error) {
            console.error('批量分配权限失败:', error)
            throw error
        }
    },

    // 批量删除角色的所有权限（优化版本）
    async removeAllRolePermissions(roleId) {
        try {
            // 先获取角色的所有权限关联记录
            const response = await this.getRolePermissions({
                pageNum: 1,
                pageSize: 1000,
                roleId: roleId
            })
            
            if (response.success && response.data.records.length > 0) {
                const relationIds = response.data.records.map(item => item.id)
                
                // 检查是否有批量删除接口，如果没有则使用并发删除
                // 分批删除，每批最多10个请求并发
                const batchSize = 10
                const batches = []
                
                for (let i = 0; i < relationIds.length; i += batchSize) {
                    batches.push(relationIds.slice(i, i + batchSize))
                }

                // 逐批处理，每批内部并发
                for (const batch of batches) {
                    const promises = batch.map(id => this.deleteRolePermission(id))
                    await Promise.all(promises)
                }
                
                return { success: true, message: `成功删除 ${relationIds.length} 个权限关联` }
            }
            
            return { success: true, message: '没有权限需要删除' }
        } catch (error) {
            console.error('批量删除权限失败:', error)
            throw error
        }
    },

    // 一次性替换角色的所有权限（推荐使用）
    async replaceRolePermissions(roleId, permissionIds) {
        try {
            // 先删除所有旧权限
            await this.removeAllRolePermissions(roleId)
            
            // 再分配新权限
            if (permissionIds && permissionIds.length > 0) {
                await this.assignPermissionsToRole(roleId, permissionIds)
            }
            
            return { success: true, message: '权限替换成功' }
        } catch (error) {
            console.error('权限替换失败:', error)
            throw error
        }
    }
}